1 门控循环单元 (GRU)

1.1 门控隐状态

门控循环单元用于控制何时更新隐状态.

1.1.1 重置门 更新门

重置门允许我们控制“可能还想记住”的过去状态的数量;
更新门允许我们控制新状态中有多少个是旧状态的副本.

这里 ${\displaystyle \sigma }$ 为 sigmoid 函数.

1.1.2 候选隐状态

将重置门 ${\displaystyle R_t}$ 与常规隐状态更新 进行集成, 得到候选隐状态: ${\displaystyle {\tilde{H}}_t\in {\mathbb{R}}^{n\times h}}$: $${\tilde{H}}_t=\tanh (X_t{W}_{xh}+(R_t\odot H_{t-1})W_{hh}+b_h)$$ (在原式基础上加了个 ${\displaystyle R_t}$). 也即, ${\displaystyle R_t}$ 中 0 越多, 就表示重置的程度越大 (趋近多层感知机), 1 越多时趋近 RNN.

1.1.3 隐状态

有了 ${\displaystyle H_{t-1}}$ 和 ${\displaystyle {\tilde{H}}_t}$, 我们需要 ${\displaystyle Z_t}$ 更新门来确定新的 ${\displaystyle H_t}$ 来自哪里: $$H_t=Z_t\odot H_{t-1}+(1-Z_t)\odot {\tilde{H}}_t.$$

1.2 从零实现

数据集导入, 同上一篇笔记:

import torch
from torch import nn
from d2l import torch as d2l

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

1.2.1 初始化参数

def get_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device)*0.01

    def three():
        return (normal((num_inputs, num_hiddens)),
                normal((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))

    W_xz, W_hz, b_z = three()  # 更新门参数
    W_xr, W_hr, b_r = three()  # 重置门参数
    W_xh, W_hh, b_h = three()  # 候选隐状态参数
    #输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    #附加梯度
    params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

1.2.2 模型

def init_gru_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device))

def gru(inputs, state, params):
    W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []
    for X in inputs:
        Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z)
        R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r)
        H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h)
        H = Z * H + (1 - Z) * H_tilda
        Y = H @ W_hq + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H,)

1.3 简洁实现

num_inputs = vocab_size
gru_layer = nn.GRU(num_inputs, num_hiddens)

2 长短期记忆网络 (LSTM)

引入长期记忆 ${\displaystyle C}$.

2.1 门控记忆元

2.1.1 输入门 输出门 遗忘门

假设有 ${\displaystyle h}$ 个隐藏单元, ${\displaystyle n}$ 批量大小, 输入 ${\displaystyle d}$. 因此输入 ${\displaystyle X_t\in {\mathbb{R}}^{n\times d}}$, 隐状态 ${\displaystyle H_{t-1}\in {\mathbb{R}}^{n\times h}}$. 输入门 ${\displaystyle I_t\in {\mathbb{R}}^{n\times h}}$, 遗忘门 ${\displaystyle F_t\in {\mathbb{R}}^{n\times h}}$, 输出门 ${\displaystyle O_t\in {\mathbb{R}}^{n\times h}}$:

这里 ${\displaystyle W_{xi},W_{xf},W_{xo}\in {\mathbb{R}}^{d\times h}}$, ${\displaystyle W_{hi},W_{hf},W_{ho}\in {\mathbb{R}}^{h\times h}}$ 是权重参数, ${\displaystyle b_i,b_f,b_o\in {\mathbb{R}}^{1\times h}}$ 是偏置参数.

2.1.2 候选记忆元

2.1.4 隐状态

输出门会根据长期记忆决定输出的内容: $$H_t=O_t\odot \tanh (C_t).$$

这就是完整版的 LSTM.

3 深度循环神经网络

4 双向循环神经网络

有些时候词语会和前后文都有关系.

4.1 隐 Markov 模型中的动态规划

假设 ${\displaystyle \mathbb{P}(x_t|h_t)}$ 控制我们观测到的 ${\displaystyle x_t}$, 隐变量的状态转移又有 ${\displaystyle \mathbb{P}(h_{t+1}|h_t)}$:

因此我们有联合概率分布 $$\begin{array}{}\text{(4.1)}& \mathbb{P}(x_1,\cdots ,x_T,h_1,\cdots ,h_T)=\prod _{t=1}^T\mathbb{P}(h_t|h_{t-1})\mathbb{P}(x_t|h_t),\mathbb{P}(h_1|h_0)=\mathbb{P}(h_1).\end{array}$$
现在假设我们观测到除了 ${\displaystyle x_j}$ 外的所有 ${\displaystyle x_i}$, 需要计算 ${\displaystyle \mathbb{P}(x_j|x_{-j})}$: $$\begin{array}{rl}\mathbb{P}(x_1,\cdots ,x_T)& =\sum _{h_1,\cdots ,h_T}\mathbb{P}(x_1,\cdots ,x_T,h_1,\cdots ,h_T)\\ & =\sum _{h_1,\cdots ,h_T}\prod _{t=1}^T\mathbb{P}(h_t|h_{t-1})\mathbb{P}(x_t|h_t)\\ & =\sum _{h_2,\cdots ,h_T}\underset{{\pi }_2(h_2)}{\underbrace{\sum _{h_1}\mathbb{P}(h_1)\mathbb{P}(x_1|h_1)\mathbb{P}(h_2|h_1)}}\mathbb{P}(x_2|h_2)\prod _{t=3}^T\mathbb{P}(h_t|h_{t-1})\mathbb{P}(x_t|h_t)\\ & =\sum _{h_3,\cdots ,h_T}\underset{{\pi }_3(h_3)}{\underbrace{\sum _{h_2}{\pi }_2(h_2)\mathbb{P}(x_2|h_2)\mathbb{P}(h_3|h_2)}}\mathbb{P}(x_3|h_3)\prod _{t=4}^T\mathbb{P}(h_t|h_{t-1})\mathbb{P}(x_t|h_t)\\ & =\cdots =\sum _{h_T}{\pi }_T(h_T)\mathbb{P}(x_T|h_T).\end{array}$$ 这里采用了动态规划的思想. 通常我们将前向递归写成 $${\pi }_{t+1}(h_{t+1})=\sum _{h_t}{\pi }_t(h_t)\mathbb{P}(x_t|h_t)\mathbb{P}(h_{t+1}|h_t),{\pi }_1(h_1)=\mathbb{P}(h_1).$$
同样地有向后递归:

因此后向递归为 $$\begin{array}{}\text{(4.2)}& {\rho }_{t-1}(h_{t-1})=\sum _{h_t}\mathbb{P}(h_t|h_{t-1})\mathbb{P}(x_t|h_t){\rho }_t(h_t),{\rho }_T(h_T)=1.\end{array}$$
这样即使遍历了所有可能的 ${\displaystyle h_t}$, 计算复杂度也从 ${\displaystyle O(k^T)}$ 下降到了 ${\displaystyle O(kT)}$. 结合前后向递归, $$\mathbb{P}(x_j|x_{-j})\propto \sum _{h_j}{\pi }_j(h_j){\rho }_j(h_j)\mathbb{P}(x_j|h_j).$$

双向模型

添加了反向传递信息的隐藏层. 在时间 ${\displaystyle t}$, 给定小批量输入 ${\displaystyle X_t\in {\mathbb{R}}^{n\times d}}$, 前后向隐状态分别为 ${\displaystyle {\overrightarrow{H}}_t,{\overleftarrow{H}}_t\in {\mathbb{R}}^{n\times h}}$, 则$$\begin{array}{rl}{\overrightarrow{H}}_t& =\varphi (X_t{W}_{xh}^{(f)}+{\overrightarrow{H}}_{t-1}{W}_{hh}^{(f)}+b_h^{(f)}),\\ {\overleftarrow{H}}_t& =\varphi (X_t{W}_{xh}^{(b)}+{\overleftarrow{H}}_{t+1}{W}_{hh}^{(b)}+b_h^{(b)}).\end{array}$$
输出层: $$O_t=H_t{W}_{hq}+b_q,$$
${\displaystyle H_t\in {\mathbb{R}}^{n\times 2h}}$ 是两个 ${\displaystyle H}$ 的连接.

双向网络在预测输出方面会有很大的性能下降, 因此只会用于填充缺失单词、词元注释等.
双向网络有很大的计算开销: 需要同时前后向计算, 且两者互相依赖.

机器翻译 数据集

编码器 解码器

我们需要一个编码器, 接受长度可变的序列, 输出固定形状的编码状态; 还需要一个解码器, 接受固定形状的编码状态, 输出长度可变的序列.

编码器

class Encoder(nn.Module):
    """编码器-解码器架构的基本编码器接口"""
    def __init__(self, **kwargs):
        super(Encoder, self).__init__(**kwargs)
    
    def forward(self, X, *args):
        raise NotImplementedError

解码器

class Decoder(nn.Module):
    """编码器-解码器架构的基本解码器接口"""
    def __init__(self, **kwargs):
        super(Decoder, self).__init__(**kwargs)

    def init_state(self, enc_outputs, *args):
        raise NotImplementedError

    def forward(self, X, state):
        raise NotImplementedError

合并两者

class EncoderDecoder(nn.Module):
    """编码器-解码器架构的基类"""
    def __init__(self, encoder, decoder, **kwargs):
        super(EncoderDecoder, self).__init__(**kwargs)
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, enc_X, dec_X, *args):
        enc_outputs = self.encoder(enc_X, *args)
        dec_state = self.decoder.init_state(enc_outputs, *args)
        return self.decoder(dec_X, dec_state)

序列到序列学习 (Seq2seq)

编码器

考虑一个 1 批量大小的序列样本: ${\displaystyle x_1,\cdots ,x_T}$, 隐状态 ${\displaystyle h_t=f(x_t,h_{t-1})}$. 编码器通过 ${\displaystyle q}$, 将隐状态转换为上下文变量 $$c=q(h_1,\cdots ,h_T).$$
这里加入嵌入层 (embedding) 来获取词元的特征向量, 嵌入层是一个 vocab_size x embed_size 的矩阵.

class Seq2SeqEncoder(d2l.Encoder):
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                 dropout=0, **kwargs):
        super(Seq2SeqEncoder, self).__init__(**kwargs)
        #嵌入层
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = nn.GRU(embed_size, num_hiddens, num_layers,
                          dropout=dropout)

    def forward(self, X, *args):
        #输出'X'的形状：(batch_size,num_steps,embed_size)
        X = self.embedding(X)
        #在循环神经网络模型中，第一个轴对应于时间步
        X = X.permute(1, 0, 2)
        #如果未提及状态，则默认为0
        output, state = self.rnn(X)
        #output的形状:(num_steps,batch_size,num_hiddens)
        #state的形状:(num_layers,batch_size,num_hiddens)
        return output, state
        
encoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16,
                         num_layers=2)
encoder.eval()
X = torch.zeros((4, 7), dtype=torch.long)
output, state = encoder(X)
output.shape

解码器

解码器学习 ${\displaystyle \mathbb{P}(y_{t^{\prime }}|y_1,\cdots ,y_{t^{\prime }-1},c)}$. 同样使用另一个循环神经网络作为解码器: ${\displaystyle s_{t^{\prime }}=g(y_{t^{\prime }-1},c,s_{t^{\prime }-1})}$.

class Seq2SeqDecoder(d2l.Decoder):
    """用于序列到序列学习的循环神经网络解码器"""
    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                 dropout=0, **kwargs):
        super(Seq2SeqDecoder, self).__init__(**kwargs)
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers,
                          dropout=dropout)
        self.dense = nn.Linear(num_hiddens, vocab_size)

    def init_state(self, enc_outputs, *args):
        return enc_outputs[1]

    def forward(self, X, state):
        #输出'X'的形状：(batch_size,num_steps,embed_size)
        X = self.embedding(X).permute(1, 0, 2)
        #广播context，使其具有与X相同的num_steps
        context = state[-1].repeat(X.shape[0], 1, 1)
        X_and_context = torch.cat((X, context), 2)
        output, state = self.rnn(X_and_context, state)
        output = self.dense(output).permute(1, 0, 2)
        #output的形状:(batch_size,num_steps,vocab_size)
        #state的形状:(num_layers,batch_size,num_hiddens)
        return output, state

使用 softmax 获得分布, 计算交叉熵损失函数来进行优化. 通过我们定义的 sequence_mask 函数, 将不相关的项屏蔽为 0:

def sequence_mask(X, valid_len, value=0):
    """在序列中屏蔽不相关的项"""
    maxlen = X.size(1)
    mask = torch.arange((maxlen), dtype=torch.float32,
                        device=X.device)[None, :] < valid_len[:, None]
    X[~mask] = value
    return X

X = torch.tensor([[1, 2, 3], [4, 5, 6]])
sequence_mask(X, torch.tensor([1, 2]))

...

评估

BLEU (Bilingual evaluation understudy) 对于预测序列的 ${\displaystyle n}$ 元语法, 评估是否出现在标签序列中.
定义 $$\exp (min(0,1-\frac{{\mathrm{len}}_{\mathrm{label}}}{{\mathrm{len}}_{\mathrm{pred}}}))\prod _{i=1}^k{p}_i^{\frac{1}{2^i}}.$$

束搜索

我们的目标是从所有可能的输出子序列 (${\displaystyle O(|\mathcal{Y}{|}^{T^{\prime }})}$) 里面找到最理想的.

贪心搜索

每一个时间步 ${\displaystyle t^{\prime }}$ 都找最高条件概率的词元:

它的问题是局部最优的组合不一定是全局最优.

穷举搜索 (略)

束搜索

束搜索 (beam search) 是两者的中间版本. 定义超参数束宽 ${\displaystyle k}$.

• 在时间步 1, 找有最高条件概率的 ${\displaystyle k}$ 个词元(${\displaystyle k}$ 个输出选项的第一个词元).
• 此后的每一步, 基于上次的 ${\displaystyle k}$ 歌候选序列, 从 ${\displaystyle k|\mathcal{Y}|}$ 个选择中继续选出最高的 ${\displaystyle k}$ 个.

复杂度 ${\displaystyle O(k|\mathcal{Y}|T^{\prime })}$, 介于两者之间.